#include "tunkia.h"
#include<QDebug>
//tunkia::tunkia()
//{

//}
QByteArray 天恒生成帧(QString 数据域)
{
    //QList<QString> 发送帧;
    //发送帧<<2;

    quint8 指令[100]={2,0,0,0,0};//长度不够,可能会引起程序崩溃

    //10=5+2+3,前5个是02 00 00 00 00 00，然后2代表是长度的两个字节，最后3代表结尾的两个校验码和03结束符
    quint8 长度=10+数据域.length();//总长度包括结尾的两个校验码和03结束符
    指令[5]=长度 / 0x100;//LENH
    指令[6]=长度 % 0x100;//LENL


    QVector<uint>v=数据域.toUcs4();

    int k=7;
    foreach(quint8 a,v)
    {
        指令[k]=a;
        k++;
    }
    quint16 校验码=crc(指令,长度-3); //CRC校验时不包括结尾的两个校验码和03结束符

    指令[k++]=校验码 / 0x100;//校验码H
    指令[k++]=校验码 % 0x100;//校验码L
    指令[k++]=0x03;//03结束符

//发送：OUT=A|DCV=1V
//十六进制帧：[02 00 00 00 00 00 16 4F 55 54 3D 41 7C 44 43 56 3D 31 56 AF CE 03]
//AF CE  45006、// CE AF 52911

   // 数据域=quint8数组转QString(指令,k);
  //  qDebug()<<"生成帧"<<数据域;
    QByteArray 生成的命令;
    for(int i=0;i<k;i++)
    {
       生成的命令.append(指令[i]);
    }



    return 生成的命令;
}


quint16 crc(quint8 * data,quint8 nbyte) //CRC 校验
{
    quint8 i,j;
    quint8 b1,b2,b3,t;
    quint8 crc16lo,crc16hi;
    quint16 crc16;
    crc16hi=data[0];
    crc16lo=data[1];
    data[nbyte]= 0;
    data[nbyte+1]= 0;
    for(i=2;i<=nbyte+1;i++)
    {
        t = data[i];
        for(j=1;j<=8;j++)
        {
            if(t>=128) { b1=1; }
            else { b1=0; }
            t=t*2;
            if(crc16lo>=128) { b2=1; }
            else { b2=0; }
            crc16lo=(crc16lo*2)|b1;
            if(crc16hi>=128) {b3=1; }
            else {b3=0; }
            crc16hi=(crc16hi*2)|b2;

            if(b3==1) { crc16hi=crc16hi^0x10; crc16lo=crc16lo^0x21; }
        }
    }
    crc16=crc16hi;
    crc16=(crc16<<8)|crc16lo;
    return crc16;
}


//并没有用到
QString quint8数组转QString(quint8 * data,int k)
{
    QString QStr命令;

    for(int i=0;i<k;i++)
    {
        if(data[i]<10)  QStr命令.append('0'+QString::number(data[i],16));
        else QStr命令.append(QString::number(data[i],16));
    }

    return QStr命令;
}
//错误类型=1正常,    0为长度为0,    2为校验错误,     10为长度小于10
QString 天恒还原帧(QByteArray 数据域, int *错误类型)
{
    int 帧长=数据域.length();
    QString 返回帧="FAIL";

    if(帧长==0){ return 返回帧; *错误类型=0;}
    if(帧长<10){ return 返回帧; *错误类型=10;}

    quint8 帧[帧长];

    int k=9;
    for(int i; k<帧长;k++)
    {
        i=数据域[k];
        if(i==3) break;//确定结束符03的位置, 暂不考虑没有03结束符的情况
    }

    for(int i=0; i<k;i++)
    {
        // qDebug()<<"kkkk"<<帧[k];
        帧[i]=数据域[i];//产生用于校验的帧
    }


    quint16 校验码=crc(帧,k-2);//为什么会将源帧的校验码变为0?

    quint8 校验码H=校验码 / 0x100;//校验码H
    quint8 校验码L=校验码 % 0x100;//校验码L


    quint8 HHHH=数据域[k-2];
    quint8 LLLL=数据域[k-1];
//    qDebug()<<"帧[k-2]"<<HHHH<<" 校验码H"<<校验码H;;
//    qDebug()<<"帧[k-1]"<<LLLL<<" 校验码L"<<校验码L;;

    *错误类型=2;
    if(校验码H==HHHH&&校验码L==LLLL)//检验校码是否正确
    {
        qDebug()<<"校验码正确"<<校验码;
        返回帧=QString::fromUtf8(数据域.mid(7,k-9));
        *错误类型=1;
    }
    返回帧=返回帧.trimmed();//去除返回帧中所有空格

    return 返回帧;
}

int32_t 天恒转int32(char *类型,QString 命令)
{

    qDebug()<<"源的获取内容"<<命令;

    int 开始,结束,长度;
    开始=命令.indexOf("|",0)+1;
    结束=命令.lastIndexOf("=");//查找字符串最后出现的位置
    长度=结束-开始;

    QString 具体命令=命令.mid(开始,长度);
    qDebug()<<"开始 结束 长度"<<开始<<结束<<长度;
    qDebug()<<"具体命令"<<具体命令;

    QString 数值字符串;
    bool ok;
    float 转换前数字;
    int 返回数值=0;


/*↓↓↓↓↓↓↓电压↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|UA=+00.0040V
    //MEAS=A|UAB=+00.0065V
    if(具体命令=="UA"||具体命令=="UB"||具体命令=="UC"||具体命令=="UAB"||具体命令=="UBC"||具体命令=="UAC")
    {
        *类型='U';
        结束=命令.lastIndexOf("V");//查找字符串最后出现的位置
      //  qDebug()<<"结束11"<<结束<<命令.length();
        if(结束==命令.length()-1)//1
        {
            开始=命令.length()-9;//9
            数值字符串=命令.mid(开始,8);//8
        }
        转换前数字=数值字符串.toFloat(&ok);
        返回数值=转换前数字*1000;
      //  qDebug()<<"数值字符串"<<数值字符串;
      //  qDebug()<<"转换前数字"<<转换前数字;
        return 返回数值;
    }

/*↓↓↓↓↓↓↓电流↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|IA=+00.0016mA，结果是0mA
    //MEAS=A|IA=+12.6016mA，结果是16mA
    //MEAS=A|IA=+11.1005A,结果是11100mA
    if(具体命令=="IA"||具体命令=="IB"||具体命令=="IC"||具体命令=="IN")
    {
        *类型='I';
        结束=命令.lastIndexOf("mA");//查找字符串最后出现的位置, 没找到结果是-1
        qDebug()<<"结束结束结束"<<结束;
        if(结束>=0)
        {
            if(结束==命令.length()-2)//找到的位置位于最后的两个
            {
                开始=命令.length()-10;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1;
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
        else
        {
            结束=命令.lastIndexOf("A");
            if(结束==命令.length()-1)//找到的位置位于最后的一个
            {
                开始=命令.length()-9;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000;
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
    }

/*↓↓↓↓↓↓↓有功P↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|PA=+42.0000W，结果是42000
    //MEAS=A|PA=+2.31006kW，结果是2310060
    if(具体命令=="PA"||具体命令=="PB"||具体命令=="PC"||具体命令=="SP")
    {
        *类型='P';
        结束=命令.lastIndexOf("kW");//查找字符串最后出现的位置, 没找到结果是-1
        qDebug()<<"结束结束结束"<<结束;
        if(结束>=0)
        {
            if(结束==命令.length()-2)//找到的位置位于最后的两个
            {
                开始=命令.length()-10;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000000;//要求校准命令的基本单位是0.001W
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
        else
        {
            结束=命令.lastIndexOf("W");
            if(结束==命令.length()-1)//找到的位置位于最后的一个
            {
                开始=命令.length()-9;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000;
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
    }
/*↓↓↓↓↓↓↓无功Q↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|QA=+36.3685var, 结果是36368
    //MEAS=A|QA=+1.45390kvar，结果是1 453 900
    if(具体命令=="QA"||具体命令=="QB"||具体命令=="QC"||具体命令=="SQ")
    {
        *类型='Q';
        结束=命令.lastIndexOf("kvar");//查找字符串最后出现的位置, 没找到结果是-1
        qDebug()<<"结束结束结束"<<结束;
        if(结束>=0)
        {
            if(结束==命令.length()-4)//找到的位置位于最后的四个
            {
                开始=命令.length()-12;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000000;//要求校准命令的基本单位是0.001var
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
        else
        {
            结束=命令.lastIndexOf("var");
            if(结束==命令.length()-3)//找到的位置位于最后的3个
            {
                开始=命令.length()-11;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000;
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
    }
/*↓↓↓↓↓↓↓视在功率S↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|SA=+045.400VA
    //MEAS=A|SS=+1.03708kVA
    if(具体命令=="SA"||具体命令=="SB"||具体命令=="SC"||具体命令=="SS")
    {
        *类型='S';
        结束=命令.lastIndexOf("kVA");//查找字符串最后出现的位置, 没找到结果是-1
        qDebug()<<"结束结束结束"<<结束;
        if(结束>=0)
        {
            if(结束==命令.length()-3)//找到的位置位于最后的3个
            {
                开始=命令.length()-11;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000000;//要求校准命令的基本单位是0.001VA
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
        else
        {
            结束=命令.lastIndexOf("VA");
            if(结束==命令.length()-2)//找到的位置位于最后的2个
            {
                开始=命令.length()-10;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000;
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }
    }
/*↓↓↓↓↓↓↓功因F↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|PFA=+1.00000,  转换成1000 000, 0xF4240
    //MEAS=A|SPF=+0.50010,  转换成500 000,  0x7A120
    if(具体命令=="PFA"||具体命令=="PFB"||具体命令=="PFC"||具体命令=="SPF")
    {
        *类型='F';

        开始=命令.length()-8;
        数值字符串=命令.mid(开始,8);
        转换前数字=数值字符串.toFloat(&ok);
        返回数值=转换前数字*1000000;
        return 返回数值;

    }
/*↓↓↓↓↓↓↓频率H↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|F=+50.0000Hz, 换成50 000，实际校准并没用到
    if(具体命令=="F")
    {
        *类型='H';

        开始=命令.length()-8;
        数值字符串=命令.mid(开始,8);
        转换前数字=数值字符串.toFloat(&ok);
        返回数值=转换前数字*1000000;
        return 返回数值;

    }
/*↓↓↓↓↓↓↓相位D↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓*/
    //MEAS=A|PHUAIA=-036.300° , 换成36 000
    //MEAS=A|PHUB=+120.000°   , 换成120 000，实际校准并没用到
    if(具体命令=="PHUAIA"||具体命令=="PHUBIB"||具体命令=="PHUCIC"||具体命令=="PHUB"||具体命令=="PHUC")
    {
        *类型='D';

        结束=命令.lastIndexOf("°");//查找字符串最后出现的位置, 没找到结果是-1
        qDebug()<<"结束结束结束"<<结束;
        if(结束>=0)
        {
            if(结束==命令.length()-1)//找到的位置位于最后的3个
            {
                开始=命令.length()-9;
                数值字符串=命令.mid(开始,8);
                转换前数字=数值字符串.toFloat(&ok);
                返回数值=转换前数字*1000;//要求校准命令的基本单位是0.001VA
                return 返回数值;
            }
            else 返回数值=0xFFFFFFFF;
            return 返回数值;

        }

    }

     return 返回数值;
}
/*
MEAS=A|UA=+00.0040V
MEAS=A|UA=+209.997V
MEAS=A|UAB=+00.0065V
MEAS=A|UAB=+210.239V

MEAS=A|IA=+00.0016mA
MEAS=A|IA=+200.006mA
MEAS=A|IA=+5.00010A
MEAS=A|IA=+11.0005A

MEAS=A|SP=+0.00000W
MEAS=A|PA=+42.0000W
MEAS=A|PA=+2.31006kW

MEAS=A|QA=-0.00000var
MEAS=A|QA=+36.3685var
MEAS=A|QA=+1.45390kvar
MEAS=A|SQ=+10.3000var
MEAS=A|SA=+045.400VA
MEAS=A|SS=+1.03708KVA
MEAS=A|PFA=+0.00000
MEAS=A|PFA=+0.50009
MEAS=A|PFA=+1.00000
MEAS=A|PFA=-0.49999
MEAS=A|SPF=+0.00000
MEAS=A|SPF=+0.50010

MEAS=A|F=+50.0000Hz
MEAS=A|PHUAIA=+000.000°
MEAS=A|PHUB=+120.000°
MEASH=A|HUA=0,0,0
MEASH=A|HIA=0,0,0
MEASH=A|HUA=4,0.150,0.000:  5,0.150,0.000:  6,0.220,0.000:  7,0.120,0.000:  8,0.100,0.000:  9,0.100,0.000
MEASH=A|HUA=4,0.150,0.000:  5,0.150,0.000:  6,0.220,0.000:  7,0.120,0.000:  8,0.100,0.000:  9,0.100,0.000
*/
